#include <iostream>
#include <unistd.h>
#include <cassert>
#include <vector>
#include "_Task.hpp"
using namespace std;

int gnum = 5;
Task t;
void waitCommend()
{
    while (true)
    {
        int commend = 0;
        int n = read(0, &commend, sizeof(int)); // 从标准输入读取指令
        // 执行指令所对应的任务
        if (n == sizeof(int))
        { // 拿到指令并执行
            t.Execute(commend);
        }
        else if (n == 0)
        {
            break;
        }
        else
        {
            break; // 读取异常
        }
    }
}
class EndPoint
{
public:
    EndPoint(int id, int fd)
        : child_id(id)
        , write_fd(fd)
    {
    }

public:
    int child_id; // 父进程所管理的子进程
    int write_fd; // 父进程所写入的管道
};
void CreatProcess(vector<EndPoint>* endPoints)
{
    for (int i = 0; i < gnum; i++)
    {
        int pipes[2] = {0}; // 准备创建管道
        int n = pipe(pipes);
        assert(n == 0);
        pid_t id = fork();
        if (id == 0)
        {
            // 子进程，读取,关闭写端pipes[1]
            close(pipes[1]);
            // 等待父进程写入，然后读取
            // 我们希望从标准输入读取，所以需要重定向
            dup2(pipes[0], 0);
            waitCommend();
            // 子进程执行结束之后退出
            close(pipes[0]);
            exit(0);
        }
        // 父进程，写入，关闭读端pipes[0]
        close(pipes[0]);
        endPoints->push_back(EndPoint(id, pipes[1])); // 创建一批子进程并进行管理每一个子进程和写入管道

        // 写入之后关闭
        //close(pipes[1]);
    }
}
int main()
{
    vector<EndPoint> endPoints;
    // 创建子进程 
    CreatProcess(&endPoints);
    while(true)
    {
        int commend =COMMEND_NETREQUEST;
        int index=rand()%endPoints.size();
        write(endPoints[index].write_fd,&commend,sizeof(commend));
        sleep(1.5);
    }
    return 0;

}
